![]() |
![]() |
|
Der Einsatz der ersten vier Operatoren zur Formulierung mathematischer Ausdrücke ist trivial. Zwei Operanden werden miteinander verknüpft und das Ergebnis der Operation der links vom Zuweisungsoperator stehenden Variablen zugewiesen.
In der Tabelle 3.6 sind drei verschiedene Divisionsoperatoren aufgeführt. Machen wir uns an einem Beispiel den Unterschied deutlich. Im folgenden Codefragment werden zwei Divisionen durchgeführt, eine auf Basis des Operators »/«, der den Nachkommaanteil im Ergebnis behält, die andere setzt mit denselben Operanden den Operator »\« ein. Das Ergebnis beider Berechnungen wird wieder an der Konsole ausgegeben.
Die Ausgabe wird lauten:
Beachten Sie insbesondere, dass der Nachkommateil der ersten Division abgeschnitten und nicht gerundet wird. Die besondere Stellung des Mod-Operators ist dadurch gekennzeichnet, dass das Ergebnis dieser Division der ganzzahlige Rest ist. Dazu ein Beispiel:
Die Zahl 17 lässt sich fünfmal in die Zahl 100 stecken (für diejenigen, deren Ausbildungsziel der Hochschulreife schon länger als zwei Jahre zurückliegt, der mathematische Beweis: 5 * 17 = 85), als Rest verbleibt danach 15, der an der Konsole ausgegeben wird. Dezimalzahlen als Operanden sind ebenfalls zugelassen, die Rückgabe ist eine Dezimalzahl:
Führen Sie diesen Code aus, wird im Konsolenfenster die Ausgabe 13,0999 erscheinen. 3.4.2 Relationale Operatoren
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
| Operator | Beschreibung |
| a = b | (Vergleichsoperator) prüft, ob der Ausdruck a dem Ausdruck b entspricht und gibt in diesem Fall True zurück |
| a <> b | Ergebnis der Operation ist True, wenn a ungleich b ist |
| a > b | Ergebnis der Operation ist True, wenn a größer b ist |
| a < b | Ergebnis der Operation ist True, wenn a kleiner b ist |
| a <= b | Ergebnis der Operation ist True, wenn a kleiner oder gleich b ist |
|
a >= b |
Ergebnis der Operation ist True, wenn a größer oder gleich b ist |
| Like | vergleicht eine gegebene Zeichenfolge mit einer zweiten oder einer Mustervorgabe |
| Is | vergleicht zwei Objekte miteinander und liefert True, wenn beide Objekte gleich sind |
| IsNot | vergleicht zwei Objekte miteinander und liefert True, wenn beide Objekte nicht gleich sind |
| TypeOf...Is | prüft ein Objekt auf einen bestimmten Typen |
Das Gleichheitszeichen dient als Zuweisungs- und als Vergleichsoperator. Welche Funktionalität ihm dabei zukommt, ergibt sich nur aus dem Kontext. Der Vergleichsoperator Like dient speziell dazu, zwei Zeichenfolgen miteinander zu vergleichen.
| Dim bolStr As Boolean |
| bolStr = "Hallo" Like "hallo" |
Das Ergebnis des Vergleichs wird False sein, weil sich die beiden Zeichenfolgeliterale im ersten Buchstaben unterscheiden. Visual Basic unterscheidet standardmäßig zwei Zeichenfolgen auf binärer Basis, differenziert also zwischen der Groß- und Kleinschreibung. Diese Standardvorgabe kann über einen Optionsschalter so verändert werden, dass nur noch ein textbasierender Vergleich erfolgt. Dazu wird außerhalb des Moduls Option Compare Text angegeben, was sich nur auf das aktuelle Modul auswirkt. Der Schalter kann auch im Projekteigenschaftsfenster gesetzt werden, was sich dann anwendungsweit auswirkt. Die Standardeinstellung dieses Optionsschalters lautet Option Compare Binary.
Der Operator Like geht in seinen Möglichkeiten aber noch deutlich weiter: Es kann auch eine Zeichenfolge mit einem Zeichenfolgemuster verglichen werden. In einem definierten Muster können Sie Platzhalter, Zeichenlisten und Zeichenbereiche in vielfältiger Kombination verwenden.
| Zeichen | Beschreibung |
| ? | Dient als Platzhalter für genau ein beliebiges Zeichen in einer Zeichenfolge. |
| * | Dient als Platzhalter für kein oder mehrere Zeichen in einer Zeichenfolge. |
| # | Dient als Platzhalter für eine Ziffer im Bereich 0 – 9 |
| [<Zeichenliste>] | Formuliert einen Zeichenbereich für ein gesuchtes Zeichen in einer Zeichenfolge. |
| [!<Zeichenliste>] | Formuliert einen ausschließenden Zeichenbereich für ein gesuchtes Zeichen in einer Zeichenfolge. |
| 'die folgenden Ausdrücke liefern alle "True" |
| bolVar = "Hallo" Like "*al*" |
| bolVar = "VB7" Like "VB#" |
| bolVar = "7Uhr" Like "#[P-U][!c-e]*" |
Unterziehen wir das letzte Beispiel einer genaueren Analyse. Das Zeichenfolgemuster des rechten Operanden verlangt durch # eine Ziffer an der ersten Position der Zeichenfolge. Durch die Zahl 7 wird diese Bedingung erfüllt. An zweiter Position muss ein Zeichen stehen, das sich im Bereich zwischen einschließlich P und U bewegen muss. Auch diese Bedingung kann erfüllt werden. Das dritte Zeichen wiederum darf kein Zeichen zwischen c und e sein – hier befindet sich der Buchstabe h im Vergleichsstring. Der Rest der Zeichenfolge kann in jeder Hinsicht beliebig sein. Damit steht fest, »7Uhr« erfüllt die Auflagen des Zeichenfolgemusters.
Vergleiche sind nicht nur auf einfache numerische Ausdrücke begrenzt. Es können auch zwei Objekte miteinander verglichen werden. Dafür ist aber das Gleichheitszeichen denkbar ungeeignet, deshalb wurde der Is-Operator eingeführt. Manchmal ist es auch von Interesse, ein Objekt auf seinen Typ zu prüfen. Dazu ist der Vergleichsoperator TypeOf...Is spezifiziert.
Logische Operatoren verbinden zwei Wahrheitswerte miteinander, um daraus einen neuen gültigen Wahrheitswert zu ermitteln. Die Operanden der logischen Operation können sowohl Werte darstellen als auch aus Vergleichsoperationen gebildet werden.
In der Datenverarbeitung spricht man von:
| True, wenn ein Vergleich zutrifft, also wahr ist |
| False, wenn der Vergleich nicht zutrifft, also falsch ist |
| Operator | Beschreibung |
| And | Das Ergebnis der Operation ist nur dann True, wenn beide Operanden True sind. Beide am Vergleich beteiligten Operanden werden geprüft. |
| Or | Das Ergebnis der Operation ist genau dann True, wenn mindestens einer der beiden Operanden True ist. Beide am Vergleich beteiligten Operanden werden geprüft. |
| Xor | Das Ergebnis der Operation ist nur dann True, wenn beide Operanden unterschiedliche Wahrheitswerte haben |
| AndAlso | Basiert auf dem And-Operator. Liefert der erste Operand False, wird der Wahrheitswert des zweiten nicht mehr überprüft. |
| OrElse | Basiert auf dem Or-Operator. Liefert der erste Operand True, wird der Wahrheitswert des zweiten nicht mehr überprüft. |
| Not | Logische Negation. Kehrt einen Wahrheitswert um. |
Das Ergebnis einer Operation, an dem logische Operatoren beteiligt sind, lässt sich am besten anhand von Wahrheitstabellen darstellen.
| Bedingung 1 | Bedingung 2 | And | Or | Xor |
| False | False | False | False | False |
| True | False | False | True | True |
| False | True | False | True | True |
| True | True | True | True | False |
Beachten Sie bitte, dass es sich bei Operanden tatsächlich um Ausdrücke handelt, die boolesche Werte repräsentieren. Daher führt die folgende Anweisung zu einer Fehlermeldung:
| 'unzulässige boolesche Operation |
| Dim bolVar As Boolean |
| bolVar = 1 And 2 |
Beide Literale werden als Integer behandelt, die nicht implizit in einen Boolean konvertiert werden können. Zur Lösung dieses Problems muss jedes Literal explizit in einen Boolean konvertiert werden:
| Dim bolVar As Boolean |
| bolVar = CBool(1) And CBool(0) |
Eine gültige boolesche Operation wäre beispielsweise:
| x < 10 And y >= 12 |
Das Ergebnis ist nur dann True, wenn x eine Zahl kleiner 10 ist und gleichzeitig y entweder größer oder gleich der Zahl 12 ist. Alle anderen Fälle gelten als False.
Betrachten wir noch einmal das obige Beispiel. Der gesamte Ausdruck kann nur dann True werden, wenn schon die erste Bedingung x < 10 True liefert. Ist x größer oder gleich 10, kann der Gesamtausdruck niemals wahr sein. Interessant ist nun die Frage, wie Visual Basic reagiert, wenn schon die erste Bedingung falsch ist. Wird der zweite Teilsausdruck noch ausgewertet, oder wird auf die zweite Bedingungsprüfung dann generell verzichtet?
Um diese Frage zu beantworten, werden zu Testzwecken zwei benutzerdefinierte Funktionen entwickelt. Funktionen ähneln den Prozeduren mit dem Unterschied, dass sie einen Rückgabewert liefern. Der Funktionsaufruf in der logischen Operation wird nach der Ausführung durch den Rückgabewert ersetzt. Im Beispielcode unten liefern die beiden Funktionen FirstCondition und SecondCondition einen Boolean als Ergebnis des Aufrufs zurück.
| ' ---------------------------------------------------- |
| ' Beispiel: ...\Kapitel 3\And_Operator |
| ' --------------------------------------------------- |
| Module Module1 |
| Sub Main() |
| Dim bolVar As Boolean |
| bolVar = FirstCondition() And SecondCondition() |
| Console.Read() |
| End Sub |
| Public Function FirstCondition() As Boolean |
| Console.WriteLine("Aufruf FirstCondition") |
| Return False |
| End Function |
| Public Function SecondCondition() As Boolean |
| Console.WriteLine("Aufruf SecondCondition") |
| Return True |
| End Function |
| End Module |
Der Rückgabewert der erstgenannten Funktion FirstCondition ist statisch und immer False, der der zweiten Funktion immer True. In der Codezeile
| bolVar = FirstCondition() And SecondCondition() |
werden beide Funktionen aufgerufen, obwohl nach der Ausführung von FirstCondition bereits feststeht, dass das Ergebnis des zweiten Funktionsaufrufs keinen Einfluss mehr auf das Gesamtergebnis mehr haben wird: bolVar wird in jedem Fall False sein.
Nun sind zwei Situationen vorstellbar: Vielleicht muss die zweite Funktion SecondCondition unbedingt ausgeführt werden, beispielsweise um innerhalb der Funktion Aktionen auszuführen, die auf den weiteren Ablauf des Programms zur Laufzeit entscheidenden Einfluss haben. Dieser Fall wird durch unser Beispiel abgedeckt. Andererseits könnte es auch sein, dass man unbedingt den Aufruf der zweiten Funktion vermeiden möchte – vielleicht nur aus dem Grund heraus, die Ausführungsgeschwindigkeit des Programms zu verbessern.
Zu diesem Zweck bietet VB 2005 mit AndAlso einen logischen Operator an, der den booleschen Wert des ersten Operanden dazu benutzt festzustellen, ob der zweite Operand überhaupt noch die Chance hat, das Ergebnis der gesamten Operation zu beeinflussen.
| Sub Main() |
| Dim bolVar As Boolean |
| bolVar = FirstCondition() AndAlso SecondCondition() |
| Console.Read() |
| End Sub |
Die Ausgabe an der Konsole zeigt, dass es erst gar nicht zur Ausführung der zweiten Funktion kommt. Die Common Language Runtime (CLR) bricht die Ausführung nach dem Aufruf der ersten Funktion ab. Sie müssen sich darüber klar sein, dass in der rechts neben AndAlso aufgeführten Funktion niemals Code implementiert werden darf, der entscheidenden Einfluss auf die Logik des Gesamtprogramms hat.
Sehr ähnlich verhalten sich auch die Operatoren Or und OrElse. Dazu ändern wir das vorhergehende Beispiel And_Operator ein wenig ab.
| ' ---------------------------------------------------- |
| ' Beispiel: ...\Kapitel 3\Or_Operator |
| ' --------------------------------------------------- |
| Module Module1 |
| Sub Main() |
| Dim bolVar As Boolean |
| bolVar = FirstCondition() Or SecondCondition() |
| Console.Read() |
| End Sub |
| Public Function FirstCondition() As Boolean |
| Console.WriteLine("Aufruf FirstCondition") |
| Return True |
| End Function |
| Public Function SecondCondition() As Boolean |
| Console.WriteLine("Aufruf SecondCondition") |
| Return True |
| End Function |
| End Module |
Der Aufruf der Funktion FirstCondition liefert diesmal True zurück. Demnach wird das Gesamtergebnis der logischen Operation in jedem Fall True sein, unabhängig vom Rückgabewert des Aufrufs der zweiten Funktion SecondCondition. Erlaubt die Programmlogik, auf den zweiten Aufruf zu verzichten, kann der Or-Operator durch OrElse ersetzt werden.
Mit dem Not-Operator lässt sich das Ergebnis einer logischen Operation umkehren:
| Dim Zahl As Long |
| ... |
| Dim bolValue As Boolean |
| bolValue = Not (Zahl > 5) |
liefert dann True als Ergebnis der gesamten Operation, wenn Zahl gleich oder kleiner 5 ist.
Das Angebot an Zuweisungsoperatoren unter VB 2005 hat sich, verglichen mit den Vorgängerversionen, drastisch erhöht. Die verkürzte Form einer Zuweisung ist nun mit nahezu allen arithmetischen Operatoren möglich.
| Operator | Beschreibung |
| = | Mit x = y wird x der Wert von y zugewiesen. |
| += | Mit x += y wird zum aktuellen Inhalt von x der Inhalt von y addiert und das Ergebnis anschließend in x gespeichert. |
| –= | Mit x –= y wird vom aktuellen Inhalt von x der Inhalt von y subtrahiert und das Ergebnis anschließend in x gespeichert. |
| *= | Mit x *= y wird der aktuelle Inhalt von x mit dem von y multipliziert und anschließend in x gespeichert. |
| /= | Mit x /= y wird der aktuelle Inhalt von x durch den Inhalt von y dividiert und anschließend in x gespeichert. Der Dezimalteil bleibt dabei erhalten. |
| \= | Mit x \= y wird der aktuelle Inhalt von x durch den Inhalt von y dividiert und anschließend in x gespeichert. Der Nachkommateil wird ohne vorhergehende Rundung abgeschnitten. |
| ^= | Mit x ^= y wird der aktuelle Inhalt von x mit y potenziert und in x gespeichert. |
| &= | Mit x &= y werden zwei Stringausdrücke verknüpft. Dabei wird dem aktuellen Inhalt des Strings x der Strings y angehängt und in x gespeichert. |
Problematisch ist immer noch der einfache Zuweisungsoperator, der sich nicht vom Vergleichsoperator unterscheidet. Nur aus dem Kontext heraus erfolgt eine Unterscheidung. Der Ausdruck
| a = b = c |
weist nicht den Inhalt von c erst b zu und danach a, sondern
| b = c |
wird als Vergleich interpretiert, der einen booleschen Wert, also True bei Gleichheit oder False bei Ungleichheit, zurückliefert. Erst nach der Vergleichsoperation wird dessen Ergebnis der Variablen a zugewiesen, die vom Typ Boolean sein muss.
Die anderen Zuweisungsoperatoren sind verkürzte Formen der arithmetischen Operatoren. Dazu ein Beispiel:
| intVar = intVar + 1 |
Der aktuelle Inhalt der Variablen intVar wird um 1 erhöht und das Ergebnis wiederum intVar zugewiesen. In der verkürzten Schreibweise könnte das auch durch
| intVar += 1 |
ausgedrückt werden. Alle arithmetischen Ausdrücke werden durch diese neue Kurznotation erfasst.
Sie werden öfters in die Situation kommen, zwei oder mehr Strings zu einem einzigen zu verketten. Visual Basic bietet zu diesem Zweck zwei Operatoren an: »&« und »+«.
| Dim strText1, strText2, strText3 As String |
| strText1 = "Visual Basic macht " |
| strText2 = "Spass" |
| strText3 = strText1 & strText2 |
| Console.WriteLine(strText3) |
Die beiden Zeichenfolgen strText1 und strText2 werden in strText3 zu einem String zusammengesetzt und dieser an der Eingabeaufforderung ausgegeben. Einer der beiden Operanden dürfte sogar eine Zahl sein, die bei der Verkettung mit & automatisch in einen String konvertiert wird.
| 'weist str "Gute N8" zu |
| str = "Gute N" & 8 |
Grundsätzlich können zwei Zeichenfolgen auch mit dem +-Operator verkettet werden. Ist einer der beiden Operanden jedoch eine Zahl, führt das zu einer Fehlermeldung der Entwicklungsumgebung.
| 'fehlerhafter Ausdruck |
| str = "Gute N" + 8 |
Der Additionsoperator versucht, eine Zeichenfolge und eine Zahl zu addieren. Dazu müsste der String in einen Double konvertiert werden, was nach allen bekannten Regeln natürlich nicht möglich ist.
Enthalten Ausdrücke mehrere Operatoren, stehen diese in einem bestimmten Prioritätsverhältnis zueinander. In der folgenden Tabelle ist dieser Sachverhalt wiedergegeben. Je weiter unten ein Operator in der Tabelle steht, desto geringer ist seine Priorität.
| Operator | Beschreibung |
| ^ | Exponentialoperator |
| – | hier: Negation |
| *, / | Multiplikation, Division |
| \ | ganzzahlige Division |
| Mod | Restwertdivision |
| +, – | Addition, Subtraktion |
| & | Stringverkettungsoperator |
| =, <>, <, >, <=, >=, TypeOf ...Is, Is, Like | Vergleichsoperatoren |
| Not | Negationsoperator |
| And, AndAlso | logisches Und |
| Or, Xor, OrElse | logisches und exklusives Oder |
Die Prioritätsregeln der Operatoren können durch entsprechende Klammerung aufgehoben werden. Geklammerte Teilausdrücke werden zuerst ausgewertet. Innerhalb der Teilausdrücke werden alle Operatoren gemäß ihrer Priorität behandelt. Falls Sie sich bei einigen Operatoren über die Priorität unsicher sind, dann sollten Sie sicherheitshalber Klammern verwenden, um die von Ihnen gewünschte Auswertungsreihenfolge sicherzustellen – Klammern haben nämlich immer höchste Priorität.
Zuweisungsoperatoren haben die geringste Priorität (Anmerkung: Beachten Sie bitte, dass der =-Operator in der Tabelle 3.12 als Vergleichs- und nicht als Zuweisungsoperator angegeben ist). Es gilt immer ganz allgemein: In einer Zuweisung wird generell der rechts vom Zuweisungsoperator stehende Ausdruck ausgewertet, bevor dann das Ergebnis der links stehenden Variablen zugewiesen wird.
Wenn Ihnen im Laufe der Zeit die Klassenbibliothek des .NET Frameworks immer vertrauter wird, werden Sie feststellen, dass viele Zustände durch die Bitstellung in einem einzelnen Byte, auch als Bitmaske bezeichnet, beschrieben werden.
Ein gutes Beispiel dafür ist die Erkennung, welche Tasten der Tastatur ein Anwender zur Laufzeit einer Windows-Anwendung gedrückt hat. Wie Sie wissen (sollten), können Sie über die Tastatur durch Tastenkombinationen das Verhalten einer Applikation steuern. In diesem Zusammenhang spielen insbesondere die Tasten (Alt), (Strg) und (Shift) eine wichtige Rolle. Wenn ein Programm beispielsweise auf die Tastenkombination (Alt) + (F1) anders reagieren soll als auf die Kombination (Alt) + (F3), muss es eine Möglichkeit geben herauszufinden, welche Tasten gleichzeitig gedrückt worden sind.
Probleme dieser Art werden häufig auf relativ einfache Art und Weise gelöst. Irgendwo in den Tiefen des Systems ist – entsprechend den Anforderungen – ein Byte reserviert (es können auch mehrere sein). Die gesetzten beziehungsweise ungesetzten Bits dieser Bitmaske beschreiben einen bestimmten, vordefinierten Zustand. Stellen wir uns dazu rein hypothetisch vor, es wäre die folgende Festlegung getroffen worden:
| (Alt)-Taste | 1001 0000 |
| (Strg)-Taste | 0000 1100 |
| (Shift)-Taste | 0100 0001 |
Es sei vom Programm ein Byte definiert, das beschreibt, ob und welche dieser drei Tasten gleichzeitig gedrückt sind. Bezeichnen wir dieses Byte im Folgenden als Tastatur-Byte. Enthält das Tastatur-Byte nur ungesetzte Bits (0000 0000), ist keine der drei Tasten gedrückt. Enthält das Tastatur-Byte 0100 1101, würde es die beiden gedrückten Tasten (Strg) und (Shift) beschreiben.
Per Programmcode muss zur Laufzeit die Bitstellung des Tatstatur-Bytes interpretiert werden. Hat der Anwender die (Alt)-Taste gedrückt oder eine andere oder gar eine Kombination? In Abhängigkeit davon führt das Programm vielleicht unterschiedliche Aktionen aus.
Grundsätzlich wird zur Lösung solcher Probleme der Or-Operator benutzt. Dazu wird der Inhalt des Tastatur-Bytes mit der definierten Bitstellung einer bestimmten Taste herangezogen. Beide werden mit dem Or-Operator verknüpft. Entspricht das Ergebnis der Bitmaske des Tastatur-Bytes, hat der Anwender die Taste gedrückt.
Dazu ein Beispiel. Wir stellen uns die Frage, ob die aktuelle Bitstellung der Bitmaske 1001 1100 auch die gedrückte Taste (Strg) beschreibt. Gehen Sie dazu wie folgt vor:
| If <Tastatur-Byte> = (<Tastatur-Byte> Or <Strg>) Then ... |
Wichtig ist, dass Sie die Klammern setzen, weil Sie ansonsten ein falsches Ergebnis erhalten. Bekanntlich hat das Gleichheitszeichen unter Visual Basic zwei Bedeutungen: Es wird sowohl als Zuweisungsoperator als auch als Vergleichsoperator eingesetzt. Innerhalb einer If-Bedingung wird es als Vergleichsoperator interpretiert und genießt damit dieselbe Priorität wie der Or-Operator. Setzen Sie keine Klammern, implementieren also
| If <Tastatur-Byte> = <Tastatur-Byte> Or <Strg> ... |
hätte das die Auswertung von links nach rechts zur Folge. Zuerst wird das Tastatur-Byte mit sich selbst verglichen. Das liefert in jedem Fall True zurück und wird damit, unabhängig vom rechten Operanden, grundsätzlich immer True für den gesamten Ausdruck sein. Sie müssen, um dieses zu vermeiden, zuerst das Tastatur-Byte mit der Bitstellung der Taste vergleichen und deshalb grundsätzlich die beiden Operanden des Or-Operators in Klammern setzen.
Die Bits 1001 1100 des Tastatur-Bytes beschreiben die Zahl 156, (Strg) wird durch die Zahl 12 repräsentiert. Damit können wir das folgende Codefragment schreiben:
| ' ----------------------------------------------------------- |
| ' Beispiel: ...\Kapitel 3\Or-Vergleich |
| ' ----------------------------------------------------------- |
| Module Module1 |
| Sub Main() |
| Dim byteStrg As Byte = 12 |
| Dim byteTastatur As Byte = 156 |
| If byteTastatur = (byteTastatur Or byteStrg) Then |
| Console.WriteLine("Bitfolge enthalten") |
| Else |
| Console.WriteLine("Bitfolge nicht enthalten.") |
| End If |
| Console.ReadLine() |
| End Sub |
| End Module |
An der Konsole wird von diesem Code
| Bitfolge enthalten |
Da Sie nun wissen, wie Sie eine Bitmaske auf eine bestimmte Bitkombination hin überprüfen, muss nun auch noch verraten werden, wie Sie bestimmte Bits setzen beziehungsweise auch wieder zurücksetzen können.
Zuerst das Setzen von Bits. Auch hierzu wird der Or-Operator benutzt:
| byteTastatur = byteTastatur Or byteShift |
Beachten Sie hierbei, dass im Gegensatz zu der If-Anweisung nun die Klammern nicht mehr Pflicht sind, da in dieser Anweisung das Gleichheitszeichen grundsätzlich immer als Zuweisungsoperator interpretiert wird. Als Zuweisungsoperator genießt das Gleichheitszeichen aber eine geringere Priorität als der Or-Operator. Demzufolge wird zuerst die Or-Verknüpfung ausgeführt und erst danach das Ergebnis der Bitmaske byteTastatur zugewiesen.
Nehmen wir nun an, die Variable byteTastatur repräsentiert die Bitkombination
| 1001 1100 |
Da gemäß den Wahrheitstabellen eine Or-Verknüpfung immer dann einen wahren Wert ergibt, wenn einer oder beide zu vergleichenden Operatoren wahr bzw. 1 ist bzw. sind, gilt:
| byteTastatur = 156 |
| byteShift = 65 |
| byteTastatur = byteTastatur Or byteShift |
Das Ergebnis lautet 221 und resultiert aus dem folgenden Bitvergleich:
| 1001 1100 |
| Or 0100 0001 |
| ------------ |
| 1101 1101 |
Die resultierende Bitmaske beschreibt nun auch die gedrückte (Shift)-Taste.
Zum Abschluss wollen wir noch aus einer gegebenen Bitmaske eine bestimmte Bitkombination herausfiltern. Hier können wir uns des Xor-Operators bedienen. Es soll das zuvor gesetzte Bit der (Shift)-Taste nun aus der Bitmaske entfernt werden:
| byteTastatur = byteTastatur Xor byteShift |
Xor liefert als Ergebnis des Vergleichs dann einen wahren Wert, wenn genau einer der beiden beteiligten Operanden wahr ist. Schauen wir uns dazu wieder den direkten Bitvergleich an:
| 1101 1101 |
| Xor 0100 0001 |
| ------------- |
| 1001 1100 |
Nun beschreibt die Bitmaske wieder ihren ursprünglichen Wert. Wir haben alle die Bits, die in unserer Definition die gedrückte (Shift)-Taste beschreiben, in der Maske zurückgesetzt.
| Arithmetische Operatoren werden für alle vier Grundrechenarten bereitgestellt sowie ein weiterer für die Potenzierung. Für die Division stehen insbesondere drei Operatoren zur Verfügung, die den Dezimalteil einer Division beibehalten, ihn abschneiden oder auch nur den ganzzahligen Rest der Operation liefern. |
| Bei den mathematischen Operationen ist zu berücksichtigen, dass der Compiler Literale immer als Integer oder als Double interpretiert. |
| Relationale Operatoren (Vergleichsoperatoren) vergleichen zwei Ausdrücke miteinander und liefern einen booleschen Wert. |
| Logische Operatoren verbinden zwei Wahrheitswerte und liefern als Ergebnis wiederum einen Wahrheitswert zurück. |
| Die Operatorpaare And und AndAlso sowie Or und OrElse unterscheiden sich im Prüfverhalten. Mit And und Or werden die beiden am Vergleich beteiligten Operanden in jedem Fall geprüft, mit AndAlso und OrElse wird auf die Prüfung des rechten Operanden verzichtet, wenn dessen Prüfergebnis keinen Einfluss auf das Resultat der gesamten Operation hat. |
| Die Operatoren Or und Xor können sowohl für Vergleichs- als auch für bitweise Operationen eingesetzt werden. |
| Das Gleichheitszeichen hat unter Visual Basic zwei Bedeutungen: Es dient als Zuweisungs- und als Vergleichsoperator. Innerhalb eines Ausdrucks, der einen Wahrheitwert zurückliefert, wird das Gleichheitszeichen als Vergleichsoperator interpretiert, ansonsten als Zuweisungsoperator. Nur aus dem syntaktischen Zusammenhang heraus lässt sich Funktionalität erkennen, die auch Konsequenzen hinsichtlich der Priorität nach sich zieht. |
| << zurück |
|
||||||||||||||
|
||||||||||||||
|
||||||||||||||
|
||||||||||||||
Copyright © Galileo Press 2007
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken.
Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die
gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich
geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung,
Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.